home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 April: Mac OS SDK / Dev.CD Apr 00 SDK1.toast / Development Kits / Mac OS / Installer SDK 1.2.3 / Upgrader 1.2.3 & Engines / Upgrader 1.2.3 / Plug-in Examples / Common Files / MWCPlusExtensions / CPlusLibPPC.cp next >
Encoding:
Text File  |  1997-04-07  |  3.0 KB  |  136 lines  |  [TEXT/CWIE]
  1.  
  2. /*
  3.  *    CPlusLibPPC.cp        -    C++ Runtime Support Routines for Metrowerks C++ (PowerPC)
  4.  *
  5.  *    Copyright © 1993 metrowerks inc. All Rights Reserved.
  6.  *
  7.  */
  8.  
  9. #include <CPlusLib.h>
  10.  
  11.  
  12. /*
  13.  *    __copy        -    copy 'size' bytes data from 'from' to 'to'
  14.  *
  15.  *    We return the pointer to the destination. If it is 0, no copy is performed.
  16.  *
  17.  */
  18.  
  19. void *__copy(char *to, char *from, size_t size)
  20. {
  21.     char *p;
  22.     
  23.     if (to && size) {
  24.         p = to;
  25.         do {
  26.             *p = *from;
  27.             ++p;
  28.             ++from;
  29.             --size;
  30.         } while (size);
  31.     }
  32.     
  33.     return(to);
  34. }
  35.  
  36.  
  37. /*
  38.  *    __init_arr    -    initialize an array of objects
  39.  *
  40.  *    Given a pointer to space for an array of 'nobjects' elements of size 'objectsize',
  41.  *    and space to store 'nobjects' and 'objectsize' (for later deletion), we call
  42.  *    the given constructor for each object in the array.
  43.  *
  44.  */
  45.  
  46. void *__init_arr(void *memptr, ConstructorDestructor constructor, size_t objectsize, size_t nobjects)
  47. {
  48.     char *p;
  49.     
  50.     if ((p = (char *) memptr) != 0) {
  51.         ((size_t *) p)[0] = objectsize;
  52.         ((size_t *) p)[1] = nobjects;
  53.         p += 2 * sizeof(size_t);
  54.         if (constructor) {
  55.             for (; nobjects--; p += objectsize)
  56.                 CTORCALL_COMPLETE(constructor, p);
  57.         }
  58.     }
  59.     
  60.     return(memptr);
  61. }
  62.  
  63.  
  64. /*
  65.  *    __new_arr    -    allocate and construct an array of objects
  66.  *
  67.  *    We allocate space for an array of 'nobjects' elements of size 'objectsize', and
  68.  *    space to store 'nobjects' and 'objectsize' (for later deletion). Then we call
  69.  *    the given constructor for each object in the array.
  70.  *
  71.  */
  72.  
  73. void *__new_arr(ConstructorDestructor constructor, size_t objectsize, size_t nobjects)
  74. {
  75.     char *memptr, *p;
  76.     
  77.     if ((memptr = (char *) ::operator new(2*sizeof(size_t) + nobjects*objectsize)) != 0) {
  78.         memptr += 2*sizeof(size_t);
  79.         ((size_t *) memptr)[-2] = objectsize;
  80.         ((size_t *) memptr)[-1] = nobjects;
  81.         if (constructor) {
  82.             for (p = memptr; nobjects--; p += objectsize)
  83.                 CTORCALL_COMPLETE(constructor, p);
  84.         }
  85.     }
  86.     
  87.     return(memptr);
  88. }
  89.  
  90.  
  91. /*
  92.  *    __del_arr    -    destroy and deallocate an array of objects
  93.  *
  94.  *    We use the previously saved 'nobjects' and 'objectsize' values to call the
  95.  *    destructor for each element of the array. Then we delete the space allocated
  96.  *    to it.
  97.  *
  98.  */
  99.  
  100. void __del_arr(void *memptr, ConstructorDestructor destructor)
  101. {
  102.     size_t nobjects, objectsize;
  103.     char *p;
  104.     
  105.     if (memptr) {
  106.         if (destructor) {
  107.             objectsize = ((size_t *) memptr)[-2];
  108.             nobjects = ((size_t *) memptr)[-1];
  109.             for (p = (char *) memptr+objectsize*nobjects; nobjects--;) {
  110.                 p -= objectsize;
  111.                 DTORCALL_COMPLETE(destructor, p);
  112.             }
  113.         }
  114.         ::delete (&((size_t *) memptr)[-2]);
  115.     }
  116. }
  117.  
  118.  
  119. /*
  120.  *    __dc_arr    -    construct or destroy a statically allocated array of objects
  121.  *
  122.  *    We call the given constructor or destructor for each of 'nobjects' elements of size
  123.  *    'objectsize' in a statically allocated array.
  124.  *
  125.  */
  126.  
  127. void __dc_arr(void *memptr, ConstructorDestructor constructordestructor, short objectsize, short nobjects)
  128. {
  129.     char *p;
  130.     
  131.     //    DTORCALL_COMPLETE isn't quite correct for constructions, 
  132.     //    but this function is not used by the current compilers.
  133.     for (p = (char *) memptr; nobjects--; p += objectsize)
  134.         DTORCALL_COMPLETE(constructordestructor, p);
  135. }
  136.